.TH std::ios_base::fmtflags 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::ios_base::fmtflags \- std::ios_base::fmtflags

.SH Synopsis
   typedef /*implementation defined*/ fmtflags;
   static constexpr fmtflags dec = /*implementation defined*/

   static constexpr fmtflags oct = /*implementation defined*/
   static constexpr fmtflags hex = /*implementation defined*/

   static constexpr fmtflags basefield = dec | oct | hex;
   static constexpr fmtflags left = /*implementation defined*/

   static constexpr fmtflags right = /*implementation defined*/
   static constexpr fmtflags internal = /*implementation defined*/

   static constexpr fmtflags adjustfield = left | right | internal;
   static constexpr fmtflags scientific = /*implementation defined*/

   static constexpr fmtflags fixed = /*implementation defined*/

   static constexpr fmtflags floatfield = scientific | fixed;
   static constexpr fmtflags boolalpha = /*implementation defined*/

   static constexpr fmtflags showbase = /*implementation defined*/
   static constexpr fmtflags showpoint = /*implementation defined*/
   static constexpr fmtflags showpos = /*implementation defined*/
   static constexpr fmtflags skipws = /*implementation defined*/
   static constexpr fmtflags unitbuf = /*implementation defined*/

   static constexpr fmtflags uppercase = /*implementation defined*/

   Specifies available formatting flags. It is a BitmaskType. The following constants
   are defined:

   Constant    Explanation
   dec         use decimal base for integer I/O: see std::dec
   oct         use octal base for integer I/O: see std::oct
   hex         use hexadecimal base for integer I/O: see std::hex
   basefield   dec | oct | hex. Useful for masking operations
   left        left adjustment (adds fill characters to the right): see std::left
   right       right adjustment (adds fill characters to the left): see std::right
   internal    internal adjustment (adds fill characters to the internal designated
               point): see std::internal
   adjustfield left | right | internal. Useful for masking operations
   scientific  generate floating point types using scientific notation, or hex notation
               if combined with fixed: see std::scientific
   fixed       generate floating point types using fixed notation, or hex notation if
               combined with scientific: see std::fixed
   floatfield  scientific | fixed. Useful for masking operations
   boolalpha   insert and extract bool type in alphanumeric format: see std::boolalpha
   showbase    generate a prefix indicating the numeric base for integer output,
               require the currency indicator in monetary I/O: see std::showbase
   showpoint   generate a decimal-point character unconditionally for floating-point
               number output: see std::showpoint
   showpos     generate a + character for non-negative numeric output: see std::showpos
   skipws      skip leading whitespace before certain input operations: see std::skipws
   unitbuf     flush the output after each output operation: see std::unitbuf
   uppercase   replace certain lowercase letters with their uppercase
               equivalents in certain output operations: see std::uppercase

.SH Example

   The following example shows several different ways to print the same result.


// Run this code

 #include <iostream>

 int main()
 {
     const int num = 150;

     // using fmtflags as class member constants:
     std::cout.setf(std::ios_base::hex, std::ios_base::basefield);
     std::cout.setf(std::ios_base::showbase);
     std::cout << num << '\\n';

     // using fmtflags as inherited class member constants:
     std::cout.setf (std::ios::hex, std::ios::basefield);
     std::cout.setf (std::ios::showbase);
     std::cout << num << '\\n';

     // using fmtflags as object member constants:
     std::cout.setf(std::cout.hex, std::cout.basefield);
     std::cout.setf(std::cout.showbase);
     std::cout << num << '\\n';

     // using fmtflags as a type:
     std::ios_base::fmtflags ff;
     ff = std::cout.flags();
     ff &= ~std::cout.basefield;   // unset basefield bits
     ff |= std::cout.hex;          // set hex
     ff |= std::cout.showbase;     // set showbase
     std::cout.flags(ff);
     std::cout << num << '\\n';

     // not using fmtflags, but using manipulators:
     std::cout << std::hex << std::showbase << num << '\\n';
 }

.SH Output:

 0x96
 0x96
 0x96
 0x96
 0x96

.SH See also

   flags        manages format flags
                \fI(public member function)\fP
   setf         sets specific format flag
                \fI(public member function)\fP
   unsetf       clears specific format flag
                \fI(public member function)\fP
   setbase      changes the base used for integer I/O
                \fI(function)\fP
   setfill      changes the fill character
                \fI(function template)\fP
   fixed
   scientific
   hexfloat     changes formatting used for floating-point I/O
   defaultfloat \fI(function)\fP
   \fI(C++11)\fP
   \fI(C++11)\fP
   showbase     controls whether prefix is used to indicate numeric base
   noshowbase   \fI(function)\fP
   boolalpha    switches between textual and numeric representation of booleans
   noboolalpha  \fI(function)\fP
   showpos      controls whether the + sign used with non-negative numbers
   noshowpos    \fI(function)\fP
   showpoint    controls whether decimal point is always included in floating-point
   noshowpoint  representation
                \fI(function)\fP
   unitbuf      controls whether output is flushed after each operation
   nounitbuf    \fI(function)\fP
   skipws       controls whether leading whitespace is skipped on input
   noskipws     \fI(function)\fP
   uppercase    controls whether uppercase characters are used with some output formats
   nouppercase  \fI(function)\fP
